package m

import (
	"GameServer/Game/cache"
	"GameServer/Game/dbmodule"
	"GameServer/Game/errors"

	"github.com/globalsign/mgo/bson"
	log "github.com/sirupsen/logrus"
)

// 委托活动玩家
type EAGamer struct {
	BaseM
	Uid         bson.ObjectId `bson:"_id" json:"_uid"`
	Name        string        `bson:"name" json:"name"`               // 名字
	Head        string        `bson:"head" json:"head"`               // 头像
	AvatarFrame int64         `bson:"avatarFrame" json:"avatarFrame"` // 头像框
	Robot       bool          `bson:"robot" json:"robot"`             // 是否是机器人

	Tid       int64 `bson:"tid" json:"tid"`             // 委托活动tid
	BeginTime int64 `bson:"beginTime" json:"beginTime"` // 委托活动开始时间
	EndTime   int64 `bson:"endTime" json:"endTime"`     // 委托活动结束时间

	HonorLst []int64      `bson:"honorLst" json:"honorLst"`   // 每个阶段荣誉
	Honor    int64        `bson:"honor" json:"honor"`         // 总荣誉
	Issue    int64        `bson:"issue" json:"issue"`         // 活动到第几期
	EntrTask *EntrustTask `bson:"entrActiv" json:"entrActiv"` // 委托任务
}

// 委托任务
type EntrustTask struct {
	Tid          int64    `bson:"tid" json:"tid"`                   // 委托tid
	TypeNum      int64    `bson:"typeNum" json:"typeNum"`           // 委托类型
	ActionEnum   int64    `bson:"actionEnum" json:"actionEnum"`     // 行为枚举
	IntegralUnit int64    `bson:"integralUnit" json:"integralUnit"` // 积分单位
	UnitNum      int64    `bson:"unitNum" json:"unitNum"`           // 单位数量
	StageLst     []*Stage `bson:"stageLst" json:"stageLst"`         // 阶段奖励
}

// 阶段奖励
type Stage struct {
	StageVal int64 `bson:"stageVal" json:"stageVal"` // 阶段值
	GoodTid  int64 `bson:"goodTid" json:"goodTid"`   // 物品tid
	GoodNum  int64 `bson:"goodNum" json:"goodNum"`   // 物品数量
	State    int64 `bson:"state" json:"state"`       // 状态 0.未完成 1.完成 2.领取
}

// 委托活动
type EAActiv struct {
	BaseM
	Uid        int64   `bson:"_id" json:"_id"`
	ActivId    int64   `bson:"activId" json:"activId"`       // 记录委托活动
	BeginTime  int64   `bson:"beginTime" json:"beginTime"`   // 委托活动开始时间
	EndTime    int64   `bson:"endTime" json:"endTime"`       // 委托活动结束时间
	Issue      int64   `bson:"issue" json:"issue"`           // 活动期次，记录当前委托任务到第几期，从0开始。
	TaskLst    []int64 `bson:"taskLst" json:"taskLst"`       // 任务tid
	RankReward int64   `bson:"rankReward" json:"rankReward"` // 排名奖励
}

// 委托活动玩家：创建
func NewEAGamer() cache.EntryI {
	return &EAGamer{}
}

// 委托活动玩家：保存信息
func (eag *EAGamer) Save() (err error) {
	err = dbmodule.MgoDB.GameDB.Upsert("EAGamer", bson.M{"_id": eag.Uid}, eag)
	if err != nil {
		return
	}
	return
}

// 委托活动玩家：加载
func (eag *EAGamer) Load(key interface{}) (err error) {
	switch key.(type) {
	case string:
		if key.(string) == "" {
			return errors.New("无效的key load, key empty")
		}
		eag.Uid = bson.ObjectIdHex(key.(string))
	case bson.ObjectId:
		eag.Uid = key.(bson.ObjectId)
	default:
		log.WithFields(log.Fields{
			"method": "EAGamer_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return eag.LoadData()
}

// 委托活动玩家：加载数据
func (eag *EAGamer) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("EAGamer", bson.M{"_id": eag.Uid}, nil, &eag)
	if err != nil {
		if err.Error() == "not found" {
			return nil
		}
		return err
	}
	return
}

// 委托活动玩家：更新数据
func (eag *EAGamer) Update(val *EAGamer) {
	Cache.Put("EAGamer", val.Uid.Hex(), val) //arG.GroupId.Hex()
	val.UpdateData()
}

func GetEAGamer(uid string) *EAGamer {
	v, _ := Cache.Get("EAGamer", uid)
	return v.(*EAGamer)
}

// 委托活动玩家：删除玩家
func ERActivDelete(uid string) (err error) {
	Cache.Remove("EAGamer", uid)
	return dbmodule.MgoDB.GameDB.Remove("EAGamer", bson.M{"_id": bson.ObjectIdHex(uid)})
}

// 委托活动玩家：删除所有玩家
func ERActivDeleteAll() (err error) {
	return dbmodule.MgoDB.GameDB.RemoveAll("EAGamer", nil)
}

// 委托活动：创建
func NewEAActiv() cache.EntryI {
	return &EAActiv{}
}

// 委托活动：保存信息
func (ea *EAActiv) Save() (err error) {
	err = dbmodule.MgoDB.GameDB.Upsert("EAActiv", bson.M{"_id": ea.Uid}, ea)
	if err != nil {
		return
	}
	return
}

// 委托活动：加载
func (ea *EAActiv) Load(key interface{}) (err error) {
	switch key.(type) {
	case int64:
		ea.Uid = key.(int64)
	default:
		log.WithFields(log.Fields{
			"method": "EAActiv_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return ea.LoadData()
}

// 委托活动：加载数据
func (ea *EAActiv) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("EAActiv", bson.M{"_id": ea.Uid}, nil, &ea)
	if err != nil {
		if err.Error() == "not found" {
			return nil
		}
		return err
	}
	return
}

// 委托活动：更新数据
func (ea *EAActiv) Update(val *EAActiv) {
	Cache.Put("EAActiv", val.Uid, val)
	val.UpdateData()
}

// 委托活动：获取数据
func GetEAActiv(uid int64) *EAActiv {
	v, _ := Cache.Get("EAActiv", uid)
	return v.(*EAActiv)
}
